This pull request includes an improvement for the data dependency generation across function calls.

Description of the issue in original data dependency implementation:

When generating dependence for an argument in a function call, its data dependence node is set to be the line this function call happens. The result is unrelated variables are pulled into the dependence, as shown in the following example:

void foo(){
    int a = 1;
    int b = 2;
    bar(a, b);
}

int bar(int a, int b){
   int result = b;
   return result;
}

In the code, result only depends on b in function foo, so when tracing the leaf dependence node for result, the expected node is the line int b = 2.
However, the current data dependence graph would point result's data dependence to the line bar(a,b). And since bar(a,b) depends on both int a = 1 and int b = 2, the leaf nodes of result's dependence graph would be int a = 1 and line int b = 2.
In large code base with many nested function calls, this easily generates too many unnecessary dependences for function call arguments.

The improvement:

The cause of this issue is how reaching definition is constructed. Reaching definition can be considered as a data structure that keeps information about the state of all variables at a program location. The state here means a set of possible locations where the variable could get its current value. In the process of the reaching definition construction, if a given source location call_loc is a function call, every parameter in this function would have this call_loc added to this set. But this call_loc is not exactly where the parameters get their values, and this is why the issue happens.

The fix does a 1-1 mapping between the symbols of function call parameters and the symbols of the arguments given for the call (utilizing information in symbol table and rw_set). Then rather than adding the function call location as the state of the parameter, it adds the current state of its corresponding argument in the call.

The modification in goto_rw.cpp are for the purpose of generating the read set from the expression of a single argument.